.TH std::valarray::operator+,-,~,! 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::valarray::operator+,-,~,! \- std::valarray::operator+,-,~,!

.SH Synopsis
   valarray<T> operator+() const;    \fB(1)\fP
   valarray<T> operator-() const;    \fB(2)\fP
   valarray<T> operator~() const;    \fB(3)\fP
   valarray<bool> operator!() const; \fB(4)\fP

   Applies unary operators to each element in the numeric array.

.SH Parameters

   \fI(none)\fP

.SH Return value

   A numeric array containing elements with values obtained by applying corresponding
   operator to the values in *this.

.SH Exceptions

   May throw implementation-defined exceptions.

.SH Notes

   Each of the operators can only be instantiated if the following requirements are
   met:

     * The indicated operator can be applied to type T.
     * The result value can be unambiguously converted to T (1-3) or bool \fB(4)\fP.

   The function can be implemented with the return type different from std::valarray.
   In this case, the replacement type has the following properties:

     * All const member functions of std::valarray are provided.
     * std::valarray, std::slice_array, std::gslice_array, std::mask_array and
       std::indirect_array can be constructed from the replacement type.
     * For every function taking a const std::valarray<T>&
       except begin() and end()
       \fI(since C++11)\fP, identical functions taking the replacement types shall be added;
     * For every function taking two const std::valarray<T>& arguments, identical
       functions taking every combination of const std::valarray<T>& and replacement
       types shall be added.
     * The return type does not add more than two levels of template nesting over the
       most deeply-nested argument type.

.SH Example


// Run this code

 #include <iostream>
 #include <string_view>
 #include <valarray>

 template<typename T>
 void print(std::string_view const note,
            std::valarray<T> const vala, // by-value, see Notes above
            std::string_view const term = "\\n")
 {
     std::cout << note << std::boolalpha << std::showpos;
     for (T const element : vala)
         std::cout << '\\t' << element;
     std::cout << term;
 }

 int main()
 {
     std::valarray<int> x{1, 2, 3, 4};
     print<int>("x: ", x);
     print<int>("+x: ", +x);
     print<int>("+ + x: ", + + x);
     print<int>("-x: ", -x);
     print<int>("- - x: ", - - x, "\\n\\n");

     std::valarray<short> y{0, 1, -1, 0x7fff};
     print<short>("y: ", y);
     print<short>("~y: ", ~y);
     print<short>("~~y: ", ~~y, "\\n\\n");

     std::valarray<bool> z{true, false};
     print<bool>("z: ", z);
     print<bool>("!z: ", !z);
     print<bool>("!!z: ", !!z);
 }

.SH Possible output:

 x:      +1      +2      +3      +4
 +x:     +1      +2      +3      +4
 + + x:  +1      +2      +3      +4
 -x:     -1      -2      -3      -4
 - - x:  +1      +2      +3      +4

 y:      +0      +1      -1      +32767
 ~y:     -1      -2      +0      -32768
 ~~y:    +0      +1      -1      +32767

 z:      true    false
 !z:     false   true
 !!z:    true    false

.SH See also

   operator+=
   operator-=
   operator*=
   operator/=
   operator%=  applies compound assignment operator to each element of the valarray
   operator&=  \fI(public member function)\fP
   operator|=
   operator^=
   operator<<=
   operator>>=
   operator+
   operator-
   operator*
   operator/
   operator%   applies binary operators to each element of two valarrays, or a valarray
   operator&   and a value
   operator|   \fI(function template)\fP
   operator^
   operator<<
   operator>>
   operator&&
   operator||

.SH Hidden category:
     * Pages with unreviewed LWG DR marker
